package com.gitee.sop.layui.adminserver.module.base.util;

import java.util.Collection;
import java.util.Map;

/**
 * 断言工具
 * @author: huwei
 * @date: 2019/10/29 17:52
 * @version: 1.0.0
 */
public final class AssertUtil {

    private AssertUtil(){
        throw new RuntimeException("静态类,禁止构建");
    }

    /**
     * 断言传入参数为真，否则抛出异常
     * @param b 检索参数
     */
    public static void isTrue(boolean b){
        isTrue(b ,"obj must be true");
    }

    /**
     * 断言传入参数b为真，否则抛出异常
     * @param b 检索参数
     * @param msg 异常信息
     */
    public static void isTrue(boolean b ,String msg){
        isTrue(b ,new RuntimeException(msg));
    }

    /**
     * 断言传入参数b为真，否则抛出异常
     * @param b 检索参数
     * @param error 异常信息
     */
    public static void isTrue(boolean b ,RuntimeException error){
        if(!b){
            throw error;
        }
    }

    /**
     * 检索传入对象为false ，否则抛出异常
     * @param b 检索参数
     */
    public static void isFalse(boolean b){
        isFalse(b ,"obj must be false");
    }

    /**
     * 检索传入对象为false ，否则抛出异常
     * @param b 检索参数
     * @param msg 异常提示消息
     */
    public static void isFalse(boolean b ,String msg){
        isFalse(b ,new RuntimeException(msg));
    }

    /**
     * 检索传入对象为false ，否则抛出异常
     * @param b 检索参数
     * @param error 异常
     */
    public static void isFalse(boolean b ,RuntimeException error){
        if(b){
            throw error;
        }
    }

    /**
     * 断言指定对象为null ，反之抛出异常
     * @param obj 检索对象
     */
    public static void isNull(Object obj){
        isNull(obj ,"obj must be null");
    }
    /**
     * 断言指定对象为null ，反之抛出异常
     * @param obj 检索对象
     * @param msg 消息提示
     */
    public static void isNull(Object obj ,String msg){
        isNull(obj ,new RuntimeException(msg));
    }
    /**
     * 断言指定对象为null ，反之抛出指定异常
     * @param obj 检索对象
     * @param error 异常对象
     */
    public static void isNull(Object obj ,RuntimeException error){
        if(obj != null){
            throw error;
        }
    }
    /**
     * 断言指定对象不能为null ,反之抛出异常
     * @param obj 检索对象
     */
    public static void notNull(Object obj){
        notNull(obj ,"obj must be not null");
    }
    /**
     * 断言指定对象不能为null ,反之抛出异常
     * @param obj 检索对象
     * @param msg 消息提示
     */
    public static void notNull(Object obj ,String msg){
        notNull(obj ,new RuntimeException(msg));
    }
    /**
     * 断言指定对象不能为null ,反之抛出指定异常
     * @param obj 检索对象
     * @param error 异常对象
     */
    public static void notNull(Object obj ,RuntimeException error){
        if(obj == null){
            throw error;
        }
    }
    /**
     * 断言指定对象不能为null，以及字符串不能为空串 ,反之抛出异常
     * @param obj 检索对象
     */
    public static void notBlank(Object obj){
        notBlank(obj ,"obj must be not blank");
    }
    /**
     * 断言指定对象不能为null，以及字符串不能为空串 ,反之抛出异常
     * @param obj 检索对象
     * @param msg 消息提示
     */
    public static void notBlank(Object obj ,String msg){
        notBlank(obj ,new RuntimeException(msg));
    }
    /**
     * 断言指定对象不能为null，以及字符串不能为空串 ,反之抛出指定异常
     * @param obj 检索对象
     * @param error 异常对象
     */
    public static void notBlank(Object obj ,RuntimeException error){
        notNull(obj, error);
        if(String.class.isAssignableFrom(obj.getClass()) && ((String)obj).trim().length() == 0){
           throw error;
        }
    }
    /**
     * 断言指定对象不能为null ，以及字符串不能为空串，数组，集合，map不能为空集，反之抛出异常
     * @param obj 检索对象
     */
    public static void notEmpty(Object obj){
        notEmpty(obj ,"obj must be not empty");
    }
    /**
     * 断言指定对象不能为null ，以及字符串不能为空串，数组，集合，map不能为空集，反之抛出异常
     * @param obj 检索对象
     * @param msg 消息提示
     */
    public static void notEmpty(Object obj ,String msg){
        notEmpty(obj ,new RuntimeException(msg));
    }
    /**
     * 断言指定对象不能为null ，以及字符串不能为空串，数组，集合，map不能为空集，反之抛出异常
     * @param obj 检索对象
     * @param error 异常对象
     */
    public static void notEmpty(Object obj ,RuntimeException error){
        notNull(obj, error);
        notBlank(obj, error);
        if(Collection.class.isAssignableFrom(obj.getClass()) && ((Collection)obj).isEmpty()){
            throw error;
        }else if(Map.class.isAssignableFrom(obj.getClass()) && ((Map)obj).isEmpty()){
            throw  error;
        }else if(obj.getClass().isArray()){
            try{
                if(((Object[]) obj).length == 0){
                    throw error;
                }
            }catch (ClassCastException e){
                //转换为Object[]失败，当前数组类型为基本数据类型的数组
                notEmptyForBaseStructArray(obj, error);
            }
        }
    }
    /**
     * 基本数据类型数组，不为空检测
     * @param obj 检索对象
     * @param error 指定异常
     */
    private static void notEmptyForBaseStructArray(Object obj ,RuntimeException error){
        if(byte[].class.isAssignableFrom(obj.getClass()) && ((byte[])obj).length == 0){
            throw error;
        }else if(short[].class.isAssignableFrom(obj.getClass()) && ((short[])obj).length == 0){
            throw error;
        }else if(int[].class.isAssignableFrom(obj.getClass()) && ((int[])obj).length == 0){
            throw error;
        }else if(long[].class.isAssignableFrom(obj.getClass()) && ((long[])obj).length == 0){
            throw error;
        }else if(double[].class.isAssignableFrom(obj.getClass()) && ((double[])obj).length == 0){
            throw error;
        }else if(float[].class.isAssignableFrom(obj.getClass()) && ((float[])obj).length == 0){
            throw error;
        }else if(char[].class.isAssignableFrom(obj.getClass()) && ((char[])obj).length == 0){
            throw error;
        }else if(boolean[].class.isAssignableFrom(obj.getClass()) && ((boolean[])obj).length == 0){
            throw error;
        }
    }
}
